package practice;

// 用队列实现栈！！

// 两个队列实现一个栈：入栈入到不为空的队列中，出栈是要出掉队列的k-1个元素
// 队列：先进先出！！
// 栈：先进后出！

import java.util.LinkedList;
import java.util.Queue;

public class MyStack {
    // 声明定义两个队列
    Queue<Integer> queue1;
    Queue<Integer> queue2;
    // 定义usedSize
    public int usedSize;

    // 初始化栈!  错误！！！
    // 初始化的是 两个队列！！
    public MyStack() {
       // MyStack myStack = new MyStack();
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
        // 注意new的对象！！！
    }


    // 入栈：判空+入到不为空的队列里
    public void push(int x) {
        // 注意队列出栈使用的方法！！
        // 注意：但是此时代码有问题：size是会变化的！！！
        // 创建临时变量，但是创建在每个所需要的内部就行

            // 判空-- 队列判空+注意入到非空中，若是都空则入到默认1中！！
            if (!queue1.isEmpty()) {
                queue1.offer(x);
            } else if (!queue2.isEmpty()) {
                queue2.offer(x);
            } else {
                // 都为空 则默认选择queue1
                queue1.offer(x);
            }
            usedSize++;
    }


    // 出栈：则将队列中的（元素-1）个移到另一个队列中
    // 哪个队列不为空就出哪个
    public int pop() {
        // 判空
        if(empty()) {
            return -1; // OJ一般不能抛出异常
        }
        // 来到这儿就说明不为空！
        if(!queue1.isEmpty()) {
            // 不空就弹出size-1个元素
            //for (int i = 0; i < queue1.size()-1; i++) {

            // 所以创建临时变量
            int curSize = queue1.size();
            for (int i = 0; i < curSize-1; i++) {
                queue2.offer(queue1.poll()); // 弹出并删除
            }
            usedSize--;
            return queue1.poll();
        } else {
            // 不空就弹出size-1个元素
            //for (int i = 0; i < queue2.size()-1; i++) {

            int curSize = queue2.size(); // 注意细节！
            for (int i = 0; i < curSize-1; i++) {
                queue1.offer(queue2.poll()); // 弹出并删除
            }
            usedSize--;
            return queue2.poll();
        }
    }

    // 获取栈顶元素：不删除--需要一个中间过渡的变量空间
    public int top() {
        // 其实主要方法类似于删除栈顶元素pop
        // 设置一个过渡的变量
        int ret = -1;
        // 判空
        if(empty()) {
            return -1; // OJ一般不能抛出异常
        }
        // 来到这儿就说明不为空！
        if(!queue1.isEmpty()) {
            // 不空就直接将size个元素放到另一个队列中
            // 所以创建临时变量
            int curSize = queue1.size();
            for (int i = 0; i < curSize; i++) {
                ret = queue1.poll(); // 弹出并删除
                queue2.offer(ret);
            }
            return ret;
        } else {
            int curSize = queue2.size();
            for (int i = 0; i < curSize; i++) {
                ret = queue2.poll(); // 弹出并删除
                queue1.offer(ret);
            }
            return ret;
        }
    }

    // 判空：判断栈中是否为空
    public boolean empty() {
        return (usedSize==0);
    }

    // 判空：判断栈中是否为空方法2
    public boolean empty2() {
        return (queue1.isEmpty()&&queue2.isEmpty());
    }


    public static void main(String[] args) {
        System.out.println("进行测试：");
        MyStack myStack = new MyStack();
        myStack.push(1);
        myStack.push(2);
        System.out.println(myStack.top());
        System.out.println(myStack.pop());
        myStack.empty();
    }
}

